Thread: while (char[ arraySize - 1] != '/0' ) Why can't I do this?

I want to input into a char array and then have a while loop determine where the input terminates. I don't understand why I can't use the above statement though. My book was really vague about the char data type.


6.33.c:11:38: warning: multi-character character constant
6.33.c: In function `main':
6.33.c:11: warning: comparison is always true due to limited range of data type

Code:

#include <stdio.h>

int testPalindrome(char[], int, int);

int main()
{
   char string[ 15 ];
   int arraySize = 15, nSize = 15;
   scanf("&#37;s", &string);

   while( string[ arraySize - 1 ] != '/0' ) {
      --arraySize;
      printf("arraySize: %d\n", arraySize);
   }

   --arraySize;
   nSize = arraySize - 1;

   printf("arraySize: %d nSize: %d\n", arraySize, nSize);
   printf("%d\n", testPalindrome(string, nSize, arraySize) );


return 0;
}



int testPalindrome(char array[], int n, int size)
{
   if (size % 2 == 1 && (size - 1) / 2 == n ) {
      // TEST STATEMENT
      printf("if 1 n: %d\n", n);
      return 1;
   }
   else if (size % 2 == 0 && (size - 1) / 2 == n) {
      // TEST STATEMENT
      printf("if 2 n: %d\n", n);
      if (array[ n ] == array[ size - n ])
         return 1;
      else
         return 0;
   }
   else {
      // TEST STATEMENT
      printf("if 3 n: %d\n", n);
      if (array[ n ] == array[ size - n - 1 ])
         return testPalindrome(array, n - 1, size);
      else
         return 0;
   }

}

Code:

while( string[ arraySize - 1 ] != '\0' )

You made a mistake there.

ssharish2005

It appears that you're using gcc. I highly recommend always using at least the -Wall flag when building with gcc. It would have caught one other problem in your code: you should pass `string' or `&string[0]' to scanf(), not `&string'. Admittedly this is a fairly pedantic correction to an almost certainly benign bug, but a bug nevertheless. The main point, though, is that -Wall will provide you a lot more warnings, almost all of them useful.

--> matsp
Do you think it's a good idea to be going beyond my book at this point though?


--> cas
What exactly does -wall do compared to pedantic?

Originally Posted by yougene

--> cas
What exactly does -wall do compared to pedantic?

-pedantic will warn about some gcc extensions; it makes the compiler a little more standards compliant. For example, `a ? : b' is valid in GNU C, but not standard C; -pedantic will warn you about that.

-Wall will warn about all sorts of potential problems, even if the C standard doesn't necessarily require a diagnostic. For example, -Wall will check to see if your arguments to printf() match up with your conversion specifiers.

If you're striving toward ANSI/ISO C compliance, a good set of options is: -Wall -std=c99 -pedantic

You might prefer c89, tastes vary.

> If you're striving toward ANSI/ISO C compliance, a good set of options is: -Wall -std=c99 -pedantic

GCC still doesn't have full C99 support (though it's getting close). So at present, C90 is the only C standard it's capable of complying with. On the other hand, it's good practice to write C code that complies with both C90 and C99 (the first because it's most common now, the second because it's the future). So -std=c99 might be useful in testing code to pick up some cases of C99 noncompliance, but is probably not a good idea to use by default.

http://gcc.gnu.org/c99status.html

Originally Posted by robatino

>So -std=c99 might be useful in testing code to pick up some cases of C99 noncompliance, but is probably not a good idea to use by default.

Hence "tastes vary". =)

Although gcc doesn't fully conform to C99, I unabashedly use some of the features that it does currently support. I've grown fond of compound literals, designated initializers, variable argument list macros, snprintf() (admittedly a library issue), stdbool, exact-width integers, among others.

It really depends on what your code targets. If you're guaranteed a recent gcc or other C99-esque compiler (such as Intel's), using C99 features may not be a bad thing. Of course, if you want to be maximally portable, C89 is still the proper target. I just don't care much about C89 compliance when it comes to code for my own personal use.

So as a beginner it would be smart for me to stick with C89?